home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1998 April: Mac OS SDK / Dev.CD Apr 98 SDK1.toast / Development Kits (Disc 1) / Interfaces&Libraries / Universal / Interfaces / PInterfaces / AppleTalk.p < prev    next >
Encoding:
Text File  |  1998-02-12  |  30.3 KB  |  827 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        AppleTalk.p
  3.  
  4.      Contains:    AppleTalk Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Release:    Universal Interfaces 3.1
  8.  
  9.      Copyright:    © 1985-1998 by Apple Computer, Inc., all rights reserved
  10.  
  11.      Bugs?:        Please include the the file and version information (from above) with
  12.                  the problem description.  Developers belonging to one of the Apple
  13.                  developer programs can submit bug reports to:
  14.  
  15.                      devsupport@apple.com
  16.  
  17. }
  18. {$IFC UNDEFINED UsingIncludes}
  19. {$SETC UsingIncludes := 0}
  20. {$ENDC}
  21.  
  22. {$IFC NOT UsingIncludes}
  23.  UNIT AppleTalk;
  24.  INTERFACE
  25. {$ENDC}
  26.  
  27. {$IFC UNDEFINED __APPLETALK__}
  28. {$SETC __APPLETALK__ := 1}
  29.  
  30. {$I+}
  31. {$SETC AppleTalkIncludes := UsingIncludes}
  32. {$SETC UsingIncludes := 1}
  33.  
  34. {$IFC UNDEFINED __MACTYPES__}
  35. {$I MacTypes.p}
  36. {$ENDC}
  37. {$IFC UNDEFINED __OSUTILS__}
  38. {$I OSUtils.p}
  39. {$ENDC}
  40.  
  41.  
  42. {$PUSH}
  43. {$ALIGN MAC68K}
  44. {$LibExport+}
  45.  
  46.  
  47. CONST
  48.                                                                 {  Driver unit numbers (ADSP is dynamic)  }
  49.     mppUnitNum                    = 9;                            {  MPP unit number  }
  50.     atpUnitNum                    = 10;                            {  ATP unit number  }
  51.     xppUnitNum                    = 40;                            {  XPP unit number  }
  52.  
  53.                                                                 {  Driver refNums (ADSP is dynamic)  }
  54.     mppRefNum                    = -10;                            {  MPP reference number  }
  55.     atpRefNum                    = -11;                            {  ATP reference number  }
  56.     xppRefNum                    = -41;                            {  XPP reference number  }
  57.  
  58.                                                                 {  .MPP csCodes  }
  59.     lookupReply                    = 242;                            {  This command queued to ourself  }
  60.     writeLAP                    = 243;                            {  Write out LAP packet  }
  61.     detachPH                    = 244;                            {  Detach LAP protocol handler  }
  62.     attachPH                    = 245;                            {  Attach LAP protocol handler  }
  63.     writeDDP                    = 246;                            {  Write out DDP packet  }
  64.     closeSkt                    = 247;                            {  Close DDP socket  }
  65.     openSkt                        = 248;                            {  Open DDP socket  }
  66.     loadNBP                        = 249;                            {  Load NBP command-executing code  }
  67.     lastResident                = 249;                            {  Last resident command  }
  68.     confirmName                    = 250;                            {  Confirm name  }
  69.     lookupName                    = 251;                            {  Look up name on internet  }
  70.     removeName                    = 252;                            {  Remove name from Names Table  }
  71.     registerName                = 253;                            {  Register name in Names Table  }
  72.     killNBP                        = 254;                            {  Kill outstanding NBP request  }
  73.     unloadNBP                    = 255;                            {  Unload NBP command code  }
  74.     setSelfSend                    = 256;                            {  MPP: Set to allow writes to self  }
  75.     SetMyZone                    = 257;                            {  Set my zone name  }
  76.     GetATalkInfo                = 258;                            {  get AppleTalk information  }
  77.     ATalkClosePrep                = 259;                            {  AppleTalk close query  }
  78.  
  79.                                                                 {  .ATP csCodes  }
  80.     nSendRequest                = 248;                            {  NSendRequest code  }
  81.     relRspCB                    = 249;                            {  Release RspCB  }
  82.     closeATPSkt                    = 250;                            {  Close ATP socket  }
  83.     addResponse                    = 251;                            {  Add response code | Require open skt  }
  84.     sendResponse                = 252;                            {  Send response code  }
  85.     getRequest                    = 253;                            {  Get request code  }
  86.     openATPSkt                    = 254;                            {  Open ATP socket  }
  87.     sendRequest                    = 255;                            {  Send request code  }
  88.     relTCB                        = 256;                            {  Release TCB  }
  89.     killGetReq                    = 257;                            {  Kill GetRequest  }
  90.     killSendReq                    = 258;                            {  Kill SendRequest  }
  91.     killAllGetReq                = 259;                            {  Kill all getRequests for a skt  }
  92.  
  93.                                                                 {  .XPP csCodes  }
  94.     openSess                    = 255;                            {  Open session  }
  95.     closeSess                    = 254;                            {  Close session  }
  96.     userCommand                    = 253;                            {  User command  }
  97.     userWrite                    = 252;                            {  User write  }
  98.     getStatus                    = 251;                            {  Get status  }
  99.     afpCall                        = 250;                            {  AFP command (buffer has command code)  }
  100.     getParms                    = 249;                            {  Get parameters  }
  101.     abortOS                        = 248;                            {  Abort open session request  }
  102.     closeAll                    = 247;                            {  Close all open sessions  }
  103.     xCall                        = 246;                            {  .XPP extended calls  }
  104.  
  105.                                                                 {  Transition Queue transition types  }
  106.     ATTransOpen                    = 0;                            { AppleTalk has opened }
  107.     ATTransClose                = 2;                            { AppleTalk is about to close }
  108.     ATTransClosePrep            = 3;                            { Is it OK to close AppleTalk ? }
  109.     ATTransCancelClose            = 4;                            { Cancel the ClosePrep transition }
  110.  
  111.     afpByteRangeLock            = 1;                            { AFPCall command codes }
  112.     afpVolClose                    = 2;                            { AFPCall command codes }
  113.     afpDirClose                    = 3;                            { AFPCall command codes }
  114.     afpForkClose                = 4;                            { AFPCall command codes }
  115.     afpCopyFile                    = 5;                            { AFPCall command codes }
  116.     afpDirCreate                = 6;                            { AFPCall command codes }
  117.     afpFileCreate                = 7;                            { AFPCall command codes }
  118.     afpDelete                    = 8;                            { AFPCall command codes }
  119.     afpEnumerate                = 9;                            { AFPCall command codes }
  120.     afpFlush                    = 10;                            { AFPCall command codes }
  121.     afpForkFlush                = 11;                            { AFPCall command codes }
  122.     afpGetDirParms                = 12;                            { AFPCall command codes }
  123.     afpGetFileParms                = 13;                            { AFPCall command codes }
  124.     afpGetForkParms                = 14;                            { AFPCall command codes }
  125.     afpGetSInfo                    = 15;                            { AFPCall command codes }
  126.     afpGetSParms                = 16;                            { AFPCall command codes }
  127.     afpGetVolParms                = 17;                            { AFPCall command codes }
  128.     afpLogin                    = 18;                            { AFPCall command codes }
  129.     afpContLogin                = 19;                            { AFPCall command codes }
  130.     afpLogout                    = 20;                            { AFPCall command codes }
  131.     afpMapID                    = 21;                            { AFPCall command codes }
  132.     afpMapName                    = 22;                            { AFPCall command codes }
  133.     afpMove                        = 23;                            { AFPCall command codes }
  134.     afpOpenVol                    = 24;                            { AFPCall command codes }
  135.     afpOpenDir                    = 25;                            { AFPCall command codes }
  136.     afpOpenFork                    = 26;                            { AFPCall command codes }
  137.     afpRead                        = 27;                            { AFPCall command codes }
  138.     afpRename                    = 28;                            { AFPCall command codes }
  139.     afpSetDirParms                = 29;                            { AFPCall command codes }
  140.     afpSetFileParms                = 30;                            { AFPCall command codes }
  141.     afpSetForkParms                = 31;                            { AFPCall command codes }
  142.     afpSetVolParms                = 32;                            { AFPCall command codes }
  143.     afpWrite                    = 33;                            { AFPCall command codes }
  144.     afpGetFlDrParms                = 34;                            { AFPCall command codes }
  145.     afpSetFlDrParms                = 35;                            { AFPCall command codes }
  146.     afpDTOpen                    = 48;                            { AFPCall command codes }
  147.     afpDTClose                    = 49;                            { AFPCall command codes }
  148.     afpGetIcon                    = 51;                            { AFPCall command codes }
  149.     afpGtIcnInfo                = 52;                            { AFPCall command codes }
  150.     afpAddAPPL                    = 53;                            { AFPCall command codes }
  151.     afpRmvAPPL                    = 54;                            { AFPCall command codes }
  152.     afpGetAPPL                    = 55;                            { AFPCall command codes }
  153.     afpAddCmt                    = 56;                            { AFPCall command codes }
  154.     afpRmvCmt                    = 57;                            { AFPCall command codes }
  155.     afpGetCmt                    = 58;                            { AFPCall command codes }
  156.     afpAddIcon                    = 192;                            { Special code for ASP Write commands }
  157.  
  158.     xppLoadedBit                = 5;                            {  XPP bit in PortBUse  }
  159.     scbMemSize                    = 192;                            {  Size of memory for SCB  }
  160.     xppFlagClr                    = 0;                            {  Cs for AFPCommandBlock  }
  161.  
  162.     xppFlagSet                    = 128;                            {  StartEndFlag & NewLineFlag fields.  }
  163.  
  164.     lapSize                        = 20;
  165.     ddpSize                        = 26;
  166.     nbpSize                        = 26;
  167.     atpSize                        = 56;
  168.  
  169.     atpXOvalue                    = 32;                            { ATP exactly-once bit  }
  170.     atpEOMvalue                    = 16;                            { ATP End-Of-Message bit  }
  171.     atpSTSvalue                    = 8;                            { ATP Send-Transmission-Status bit  }
  172.     atpTIDValidvalue            = 2;                            { ATP trans. ID valid bit  }
  173.     atpSendChkvalue                = 1;                            { ATP send checksum bit  }
  174.  
  175.     zipGetLocalZones            = 5;
  176.     zipGetZoneList                = 6;
  177.     zipGetMyZone                = 7;
  178.  
  179.     LAPMgrPtr                    = $0B18;                        { Entry point for LAP Manager }
  180.  
  181.     LAPMgrCall                    = 2;                            { Offset to LAP routines }
  182.     LAddAEQ                        = 23;                            { LAPAddATQ routine selector }
  183.     LRmvAEQ                        = 24;                            { LAPRmvATQ routine selector }
  184.  
  185.     tLAPRead                    = 0;
  186.     tLAPWrite                    = 1;
  187.     tDDPRead                    = 2;
  188.     tDDPWrite                    = 3;
  189.     tNBPLookup                    = 4;
  190.     tNBPConfirm                    = 5;
  191.     tNBPRegister                = 6;
  192.     tATPSndRequest                = 7;
  193.     tATPGetRequest                = 8;
  194.     tATPSdRsp                    = 9;
  195.     tATPAddRsp                    = 10;
  196.     tATPRequest                    = 11;
  197.     tATPResponse                = 12;
  198.  
  199.  
  200. TYPE
  201.     ABCallType                            = SInt8;
  202.  
  203. CONST
  204.     lapProto                    = 0;
  205.     ddpProto                    = 1;
  206.     nbpProto                    = 2;
  207.     atpProto                    = 3;
  208.  
  209.  
  210. TYPE
  211.     ABProtoType                            = UInt8;
  212.     ABByte                                = Byte;
  213.     LAPAdrBlockPtr = ^LAPAdrBlock;
  214.     LAPAdrBlock = PACKED RECORD
  215.         dstNodeID:                UInt8;
  216.         srcNodeID:                UInt8;
  217.         lapProtType:            ABByte;
  218.         filler:                    UInt8;                                    {     Filler for proper byte alignment }
  219.     END;
  220.  
  221.     ATQEntryPtr = ^ATQEntry;
  222. {$IFC TYPED_FUNCTION_POINTERS}
  223.     ATalkTransitionEventProcPtr = FUNCTION(eventCode: LONGINT; qElem: ATQEntryPtr; eventParameter: UNIV Ptr): LONGINT; C;
  224. {$ELSEC}
  225.     ATalkTransitionEventProcPtr = ProcPtr;
  226. {$ENDC}
  227.  
  228.     ATalkTransitionEventUPP = UniversalProcPtr;
  229.     ATalkTransitionEvent                = ATalkTransitionEventUPP;
  230.     ATQEntry = RECORD
  231.         qLink:                    ATQEntryPtr;                            { next queue entry }
  232.         qType:                    INTEGER;                                { queue type }
  233.         CallAddr:                ATalkTransitionEventUPP;                { your routine descriptor }
  234.     END;
  235.  
  236. { 
  237.     Real definition of EntityName is 3 PACKED strings of any length (32 is just an example). No
  238.     offests for Asm since each String address must be calculated by adding length byte to last string ptr.
  239.     In Pascal, String(32) will be 34 bytes long since fields never start on an odd byte unless they are 
  240.     only a byte long. So this will generate correct looking interfaces for Pascal and C, but they will not
  241.     be the same, which is OK since they are not used. 
  242. }
  243.     EntityNamePtr = ^EntityName;
  244.     EntityName = RECORD
  245.         objStr:                    Str32Field;
  246.         typeStr:                Str32Field;
  247.         zoneStr:                Str32Field;
  248.     END;
  249.  
  250.     EntityPtr                            = ^EntityName;
  251.     AddrBlockPtr = ^AddrBlock;
  252.     AddrBlock = PACKED RECORD
  253.         aNet:                    UInt16;
  254.         aNode:                    UInt8;
  255.         aSocket:                UInt8;
  256.     END;
  257.  
  258.     RetransTypePtr = ^RetransType;
  259.     RetransType = PACKED RECORD
  260.         retransInterval:        UInt8;
  261.         retransCount:            UInt8;
  262.     END;
  263.  
  264.     BDSElementPtr = ^BDSElement;
  265.     BDSElement = RECORD
  266.         buffSize:                INTEGER;
  267.         buffPtr:                Ptr;
  268.         dataSize:                INTEGER;
  269.         userBytes:                LONGINT;
  270.     END;
  271.  
  272.     BDSType                                = ARRAY [0..7] OF BDSElement;
  273.     BDSPtr                                = ^BDSElement;
  274.     BitMapType = PACKED ARRAY [0..7] OF BOOLEAN;
  275.     ATLAPRecPtr = ^ATLAPRec;
  276.     ATLAPRec = RECORD
  277.         abOpcode:                ABCallType;
  278.         filler:                    SInt8;                                    {     Filler for proper byte alignment }
  279.         abResult:                INTEGER;
  280.         abUserReference:        LONGINT;
  281.         lapAddress:                LAPAdrBlock;
  282.         lapReqCount:            INTEGER;
  283.         lapActCount:            INTEGER;
  284.         lapDataPtr:                Ptr;
  285.     END;
  286.  
  287.     ATLAPRecHandle                        = ^ATLAPRecPtr;
  288.     ATDDPRecPtr = ^ATDDPRec;
  289.     ATDDPRec = RECORD
  290.         abOpcode:                ABCallType;
  291.         filler:                    SInt8;                                    {     Filler for proper byte alignment }
  292.         abResult:                INTEGER;
  293.         abUserReference:        LONGINT;
  294.         ddpType:                INTEGER;
  295.         ddpSocket:                INTEGER;
  296.         ddpAddress:                AddrBlock;
  297.         ddpReqCount:            INTEGER;
  298.         ddpActCount:            INTEGER;
  299.         ddpDataPtr:                Ptr;
  300.         ddpNodeID:                INTEGER;
  301.     END;
  302.  
  303.     ATDDPRecHandle                        = ^ATDDPRecPtr;
  304.     ATNBPRecPtr = ^ATNBPRec;
  305.     ATNBPRec = RECORD
  306.         abOpcode:                ABCallType;
  307.         filler:                    SInt8;                                    {     Filler for proper byte alignment }
  308.         abResult:                INTEGER;
  309.         abUserReference:        LONGINT;
  310.         nbpEntityPtr:            EntityPtr;
  311.         nbpBufPtr:                Ptr;
  312.         nbpBufSize:                INTEGER;
  313.         nbpDataField:            INTEGER;
  314.         nbpAddress:                AddrBlock;
  315.         nbpRetransmitInfo:        RetransType;
  316.     END;
  317.  
  318.     ATNBPRecHandle                        = ^ATNBPRecPtr;
  319.     ATATPRecPtr = ^ATATPRec;
  320.     ATATPRec = RECORD
  321.         abOpcode:                ABCallType;
  322.         filler1:                SInt8;                                    {     Filler for proper byte alignment }
  323.         abResult:                INTEGER;
  324.         abUserReference:        LONGINT;
  325.         atpSocket:                INTEGER;
  326.         atpAddress:                AddrBlock;
  327.         atpReqCount:            INTEGER;
  328.         atpDataPtr:                Ptr;
  329.         atpRspBDSPtr:            BDSPtr;
  330.         atpBitMap:                SInt8;
  331.         filler2:                SInt8;                                    {     Filler for proper byte alignment }
  332.         atpTransID:                INTEGER;
  333.         atpActCount:            INTEGER;
  334.         atpUserData:            LONGINT;
  335.         atpXO:                    BOOLEAN;
  336.         atpEOM:                    BOOLEAN;
  337.         atpTimeOut:                INTEGER;
  338.         atpRetries:                INTEGER;
  339.         atpNumBufs:                INTEGER;
  340.         atpNumRsp:                INTEGER;
  341.         atpBDSSize:                INTEGER;
  342.         atpRspUData:            LONGINT;
  343.         atpRspBuf:                Ptr;
  344.         atpRspSize:                INTEGER;
  345.     END;
  346.  
  347.     ATATPRecHandle                        = ^ATATPRecPtr;
  348.     AFPCommandBlockPtr = ^AFPCommandBlock;
  349.     AFPCommandBlock = PACKED RECORD
  350.         cmdByte:                UInt8;
  351.         startEndFlag:            UInt8;
  352.         forkRefNum:                INTEGER;
  353.         rwOffset:                LONGINT;
  354.         reqCount:                LONGINT;
  355.         newLineFlag:            UInt8;
  356.         newLineChar:            CHAR;
  357.     END;
  358.  
  359.     MPPPBPtr                            = ^MPPParamBlock;
  360.     ATPPBPtr                            = ^ATPParamBlock;
  361.     XPPParmBlkPtr                        = ^XPPParamBlock;
  362. {$IFC TYPED_FUNCTION_POINTERS}
  363.     MPPCompletionProcPtr = PROCEDURE(thePBptr: MPPPBPtr);
  364. {$ELSEC}
  365.     MPPCompletionProcPtr = Register68kProcPtr;
  366. {$ENDC}
  367.  
  368. {$IFC TYPED_FUNCTION_POINTERS}
  369.     ATPCompletionProcPtr = PROCEDURE(thePBptr: ATPPBPtr);
  370. {$ELSEC}
  371.     ATPCompletionProcPtr = Register68kProcPtr;
  372. {$ENDC}
  373.  
  374. {$IFC TYPED_FUNCTION_POINTERS}
  375.     XPPCompletionProcPtr = PROCEDURE(thePBptr: XPPParmBlkPtr);
  376. {$ELSEC}
  377.     XPPCompletionProcPtr = Register68kProcPtr;
  378. {$ENDC}
  379.  
  380. {$IFC TYPED_FUNCTION_POINTERS}
  381.     AttnRoutineProcPtr = PROCEDURE(sessRefnum: INTEGER; attnBytes: INTEGER);
  382. {$ELSEC}
  383.     AttnRoutineProcPtr = Register68kProcPtr;
  384. {$ENDC}
  385.  
  386.     MPPCompletionUPP = UniversalProcPtr;
  387.     ATPCompletionUPP = UniversalProcPtr;
  388.     XPPCompletionUPP = UniversalProcPtr;
  389.     AttnRoutineUPP = UniversalProcPtr;
  390.  
  391.     WDSElementPtr = ^WDSElement;
  392.     WDSElement = RECORD
  393.         entryLength:            INTEGER;
  394.         entryPtr:                Ptr;
  395.     END;
  396.  
  397.     NTElementPtr = ^NTElement;
  398.     NTElement = RECORD
  399.         nteAddress:                AddrBlock;                                { network address of entity }
  400.         filler:                    SInt8;
  401.         entityData:                ARRAY [0..98] OF SInt8;                    { Object, Type & Zone }
  402.     END;
  403.  
  404.     NamesTableEntryPtr = ^NamesTableEntry;
  405.     NamesTableEntry = RECORD
  406.         qNext:                    Ptr;                                    { ptr to next NTE }
  407.         nt:                        NTElement;
  408.     END;
  409.  
  410. {$IFC TYPED_FUNCTION_POINTERS}
  411.     MPPProtocolHandlerProcPtr = FUNCTION(SCCAddr1: Ptr; SCCAddr2: Ptr; MPPLocalVars: Ptr; nextFreeByteInRHA: Ptr; ReadPacketAndReadRestPtr: Ptr; numBytesLeftToReadInPacket: INTEGER): BOOLEAN;
  412. {$ELSEC}
  413.     MPPProtocolHandlerProcPtr = Register68kProcPtr;
  414. {$ENDC}
  415.  
  416. {$IFC TYPED_FUNCTION_POINTERS}
  417.     DDPSocketListenerProcPtr = FUNCTION(SCCAddr1: Ptr; SCCAddr2: Ptr; MPPLocalVars: Ptr; nextFreeByteInRHA: Ptr; ReadPacketAndReadRestPtr: Ptr; packetDestinationNumber: ByteParameter; numBytesLeftToReadInPacket: INTEGER): BOOLEAN;
  418. {$ELSEC}
  419.     DDPSocketListenerProcPtr = Register68kProcPtr;
  420. {$ENDC}
  421.  
  422.     MPPProtocolHandlerUPP = UniversalProcPtr;
  423.     DDPSocketListenerUPP = UniversalProcPtr;
  424. {
  425.     MPPProtocolHandlerProcs and  DDPSocketListenerProcs cannot be written 
  426.     in or called from a high-level language without the help of mixed mode 
  427.     or assembly glue because they use the following parameter-passing conventions:
  428.  
  429.     typedef Boolean (*MPPProtocolHandlerProcPtr)(Ptr SCCAddr1, Ptr SCCAddr2, 
  430.             Ptr MPPLocalVars, Ptr nextFreeByteInRHA, Ptr ReadPacketAndReadRestPtr, 
  431.             short numBytesLeftToReadInPacket);
  432.  
  433.         In:
  434.             =>    SCCAddr1                    A0.L
  435.             =>    SCCAddr2                    A1.L
  436.             =>    MPPLocalVars                A2.L
  437.             =>    nextFreeByteInRHA            A3.L
  438.             =>    ReadPacketAndReadRestPtr    A4.L
  439.             =>    numBytesLeftToReadInPacket    D1.W
  440.         Out:
  441.             <=    Boolean                        Z bit of CCR
  442.  
  443.     typedef Boolean (*DDPSocketListenerProcPtr)(Ptr SCCAddr1, Ptr SCCAddr2, 
  444.             Ptr MPPLocalVars, Ptr nextFreeByteInRHA, Ptr ReadPacketAndReadRestPtr, 
  445.             UInt8 packetDestinationNumber, short numBytesLeftToReadInPacket);
  446.  
  447.         In:
  448.             =>    SCCAddr1                    A0.L
  449.             =>    SCCAddr2                    A1.L
  450.             =>    MPPLocalVars                A2.L
  451.             =>    nextFreeByteInRHA            A3.L
  452.             =>    ReadPacketAndReadRestPtr    A4.L
  453.             =>    packetDestinationNumber        D0.B
  454.             =>    numBytesLeftToReadInPacket    D1.W
  455.         Out:
  456.             <=    Boolean                        Z bit of CCR
  457.  
  458. }
  459.     MPPParamBlockPtr = ^MPPParamBlock;
  460.     MPPParamBlock = PACKED RECORD
  461.         qLink:                    QElemPtr;                                { next queue entry }
  462.         qType:                    INTEGER;                                { queue type }
  463.         ioTrap:                    INTEGER;                                { routine trap }
  464.         ioCmdAddr:                Ptr;                                    { routine address }
  465.         ioCompletion:            ATPCompletionUPP;                        { ATPCompletionUPP or MPPCompletionUPP }
  466.         ioResult:                OSErr;                                    { result code }
  467.         userData:                LONGINT;                                { Command result (ATP user bytes) }
  468.         reqTID:                    INTEGER;                                { request transaction ID }
  469.         ioRefNum:                INTEGER;                                { driver reference number }
  470.         csCode:                    INTEGER;                                { Call command code }
  471.         CASE INTEGER OF
  472.         0: (
  473.             filler0:            INTEGER;
  474.             wdsPointer:            Ptr;
  475.            );
  476.         1: (
  477.             protType:            UInt8;
  478.             filler:                SInt8;
  479.             handler:            MPPProtocolHandlerUPP;
  480.            );
  481.         2: (
  482.             socket:                UInt8;
  483.             checksumFlag:        UInt8;
  484.             listener:            DDPSocketListenerUPP;
  485.            );
  486.         3: (
  487.             interval:            UInt8;                                    { retry interval  }
  488.             count:                UInt8;                                    { retry count  }
  489.             nbpPtrs:            Ptr;
  490.             CASE INTEGER OF
  491.             0: (
  492.                 verifyFlag:        UInt8;
  493.                 filler3:        UInt8;
  494.                );
  495.             1: (
  496.                 retBuffPtr:        Ptr;
  497.                 retBuffSize:    INTEGER;
  498.                 maxToGet:        INTEGER;
  499.                 numGotten:        INTEGER;
  500.                );
  501.             2: (
  502.                 confirmAddr:    AddrBlock;
  503.                 newSocket:        UInt8;
  504.                 filler4:        UInt8;
  505.                );
  506.                );
  507.             4: (
  508.                 newSelfFlag:    UInt8;                                    { self-send toggle flag  }
  509.                 oldSelfFlag:    UInt8;                                    { previous self-send state  }
  510.                );
  511.             5: (
  512.                 nKillQEl:        Ptr;                                    { ptr to i/o queue element to cancel  }
  513.                );
  514.             6: (
  515.                 version:        INTEGER;                                { requested info version }
  516.                 varsPtr:        Ptr;                                    { pointer to well known MPP vars }
  517.                 DCEPtr:            Ptr;                                    { pointer to MPP DCE }
  518.                 portID:            INTEGER;                                { port number [0..7] }
  519.                 configuration:    LONGINT;                                { 32-bit configuration word }
  520.                 selfSend:        INTEGER;                                { non zero if SelfSend enabled }
  521.                 netLo:            INTEGER;                                { low value of network range }
  522.                 netHi:            INTEGER;                                { high value of network range }
  523.                 ourAdd:            LONGINT;                                { our 24-bit AppleTalk address }
  524.                 routerAddr:        LONGINT;                                { 24-bit address of (last) router }
  525.                 numOfPHs:        INTEGER;                                { max. number of protocol handlers }
  526.                 numOfSkts:        INTEGER;                                { max. number of static sockets }
  527.                 numNBPEs:        INTEGER;                                { max. concurrent NBP requests }
  528.                 nTQueue:        Ptr;                                    { pointer to registered name queue }
  529.                 LAlength:        INTEGER;                                { length in bytes of data link addr }
  530.                 linkAddr:        Ptr;                                    { data link address returned }
  531.                 zoneName:        Ptr;                                    { zone name returned }
  532.                );
  533.             7: (
  534.                 appName:        Ptr;                                    { pointer to application name in buffer }
  535.                );
  536.     END;
  537.  
  538.  
  539.     XPPParamBlockPtr = ^XPPParamBlock;
  540.     XPPParamBlock = PACKED RECORD
  541.         qLink:                    QElemPtr;
  542.         qType:                    INTEGER;
  543.         ioTrap:                    INTEGER;
  544.         ioCmdAddr:                Ptr;
  545.         ioCompletion:            XPPCompletionUPP;
  546.         ioResult:                OSErr;
  547.         cmdResult:                LONGINT;
  548.         ioVRefNum:                INTEGER;
  549.         ioRefNum:                INTEGER;
  550.         csCode:                    INTEGER;
  551.         CASE INTEGER OF
  552.         0: (
  553.             abortSCBPtr:        Ptr;                                    {  SCB pointer for AbortOS }
  554.            );
  555.         1: (
  556.             aspMaxCmdSize:        INTEGER;                                { For SPGetParms }
  557.             aspQuantumSize:        INTEGER;
  558.             numSesss:            INTEGER;
  559.            );
  560.         2: (
  561.             sessRefnum:            INTEGER;                                { Offset to session refnum  }
  562.             aspTimeout:            UInt8;                                    { Timeout for ATP  }
  563.             aspRetry:            UInt8;                                    { Retry count for ATP  }
  564.             CASE INTEGER OF
  565.             0: (
  566.                 serverAddr:        AddrBlock;                                { Server address block  }
  567.                 scbPointer:        Ptr;                                    { SCB pointer  }
  568.                 attnRoutine:    AttnRoutineUPP;                            { Attention routine pointer }
  569.                );
  570.             1: (
  571.                 cbSize:            INTEGER;                                { Command block size  }
  572.                 cbPtr:            Ptr;                                    { Command block pointer  }
  573.                 rbSize:            INTEGER;                                { Reply buffer size  }
  574.                 rbPtr:            Ptr;                                    { Reply buffer pointer  }
  575.                 CASE INTEGER OF
  576.                 0: (
  577.                     afpAddrBlock: AddrBlock;                            { block in AFP login  }
  578.                     afpSCBPtr:    Ptr;                                    { SCB pointer in AFP login  }
  579.                     afpAttnRoutine: AttnRoutineUPP;                        { routine pointer in AFP login  }
  580.                    );
  581.                 1: (
  582.                     wdSize:        INTEGER;                                { Write Data size }
  583.                     wdPtr:        Ptr;                                    { Write Data pointer }
  584.                     ccbStart:    PACKED ARRAY [0..295] OF UInt8;            { CCB memory allocated for driver afpWrite max size(CCB)=296 all other calls=150 }
  585.                    );
  586.                    );
  587.                    );
  588.                 3: (
  589.                     xppSubCode:    INTEGER;
  590.                     xppTimeout:    UInt8;                                    { retry interval (seconds) }
  591.                     xppRetry:    UInt8;                                    { retry count }
  592.                     filler1:    INTEGER;
  593.                     zipBuffPtr:    Ptr;                                    { pointer to buffer (must be 578 bytes) }
  594.                     zipNumZones: INTEGER;                                { no. of zone names in this response }
  595.                     zipLastFlag: UInt8;                                    { non-zero if no more zones }
  596.                     filler2:    UInt8;                                    { filler }
  597.                     zipInfoField: PACKED ARRAY [1..70] OF UInt8;        { on initial call, set first word to zero }
  598.                    );
  599.     END;
  600.  
  601.     ATPParamBlockPtr = ^ATPParamBlock;
  602.     ATPParamBlock = PACKED RECORD
  603.         qLink:                    QElemPtr;                                { next queue entry }
  604.         qType:                    INTEGER;                                { queue type }
  605.         ioTrap:                    INTEGER;                                { routine trap }
  606.         ioCmdAddr:                Ptr;                                    { routine address }
  607.         ioCompletion:            ATPCompletionUPP;                        { ATPCompletionUPP or MPPCompletionUPP }
  608.         ioResult:                OSErr;                                    { result code }
  609.         userData:                LONGINT;                                { Command result (ATP user bytes) }
  610.         reqTID:                    INTEGER;                                { request transaction ID }
  611.         ioRefNum:                INTEGER;                                { driver reference number }
  612.         csCode:                    INTEGER;                                { Call command code }
  613.         atpSocket:                UInt8;                                    { currbitmap for requests or ATP socket number }
  614.         atpFlags:                UInt8;                                    { control information }
  615.         addrBlock:                AddrBlock;                                { source/dest. socket address }
  616.         reqLength:                INTEGER;                                { request/response length }
  617.         reqPointer:                Ptr;                                    { ->request/response Data }
  618.         bdsPointer:                Ptr;                                    { ->response BDS  }
  619.         CASE INTEGER OF
  620.         0: (
  621.             numOfBuffs:            UInt8;                                    { numOfBuffs  }
  622.             timeOutVal:            UInt8;                                    { timeout interval  }
  623.             numOfResps:            UInt8;                                    { number of responses actually received  }
  624.             retryCount:            UInt8;                                    { number of retries  }
  625.             intBuff:            INTEGER;                                { used internally for NSendRequest  }
  626.             TRelTime:            UInt8;                                    { TRelease time for extended send request  }
  627.             filler0:            SInt8;
  628.            );
  629.         1: (
  630.             filler:                UInt8;
  631.             bdsSize:            UInt8;                                    { number of BDS elements  }
  632.             transID:            INTEGER;                                { transaction ID recd.  }
  633.            );
  634.         2: (
  635.             bitMap:                UInt8;
  636.             filler2:            UInt8;
  637.            );
  638.         3: (
  639.             rspNum:                UInt8;
  640.             filler3:            UInt8;
  641.            );
  642.         4: (
  643.             aKillQEl:            Ptr;                                    { ptr to i/o queue element to cancel }
  644.            );
  645.     END;
  646.  
  647.  
  648. CONST
  649.     uppATalkTransitionEventProcInfo = $00000FF1;
  650.     uppMPPCompletionProcInfo = $00009802;
  651.     uppATPCompletionProcInfo = $00009802;
  652.     uppXPPCompletionProcInfo = $00009802;
  653.     uppAttnRoutineProcInfo = $00061002;
  654.     uppMPPProtocolHandlerProcInfo = $0000007F;
  655.     uppDDPSocketListenerProcInfo = $0000008F;
  656.  
  657. FUNCTION NewATalkTransitionEventProc(userRoutine: ATalkTransitionEventProcPtr): ATalkTransitionEventUPP;
  658.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  659.     INLINE $2E9F;
  660.     {$ENDC}
  661.  
  662. FUNCTION NewMPPCompletionProc(userRoutine: MPPCompletionProcPtr): MPPCompletionUPP;
  663.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  664.     INLINE $2E9F;
  665.     {$ENDC}
  666.  
  667. FUNCTION NewATPCompletionProc(userRoutine: ATPCompletionProcPtr): ATPCompletionUPP;
  668.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  669.     INLINE $2E9F;
  670.     {$ENDC}
  671.  
  672. FUNCTION NewXPPCompletionProc(userRoutine: XPPCompletionProcPtr): XPPCompletionUPP;
  673.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  674.     INLINE $2E9F;
  675.     {$ENDC}
  676.  
  677. FUNCTION NewAttnRoutineProc(userRoutine: AttnRoutineProcPtr): AttnRoutineUPP;
  678.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  679.     INLINE $2E9F;
  680.     {$ENDC}
  681.  
  682. FUNCTION NewMPPProtocolHandlerProc(userRoutine: MPPProtocolHandlerProcPtr): MPPProtocolHandlerUPP;
  683.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  684.     INLINE $2E9F;
  685.     {$ENDC}
  686.  
  687. FUNCTION NewDDPSocketListenerProc(userRoutine: DDPSocketListenerProcPtr): DDPSocketListenerUPP;
  688.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  689.     INLINE $2E9F;
  690.     {$ENDC}
  691.  
  692. FUNCTION CallATalkTransitionEventProc(eventCode: LONGINT; qElem: ATQEntryPtr; eventParameter: UNIV Ptr; userRoutine: ATalkTransitionEventUPP): LONGINT;
  693.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  694.     {To be implemented:  Glue to move parameters into registers.}
  695.     {$ENDC}
  696.  
  697. PROCEDURE CallMPPCompletionProc(thePBptr: MPPPBPtr; userRoutine: MPPCompletionUPP);
  698.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  699.     {To be implemented:  Glue to move parameters into registers.}
  700.     {$ENDC}
  701.  
  702. PROCEDURE CallATPCompletionProc(thePBptr: ATPPBPtr; userRoutine: ATPCompletionUPP);
  703.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  704.     {To be implemented:  Glue to move parameters into registers.}
  705.     {$ENDC}
  706.  
  707. PROCEDURE CallXPPCompletionProc(thePBptr: XPPParmBlkPtr; userRoutine: XPPCompletionUPP);
  708.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  709.     {To be implemented:  Glue to move parameters into registers.}
  710.     {$ENDC}
  711.  
  712. PROCEDURE CallAttnRoutineProc(sessRefnum: INTEGER; attnBytes: INTEGER; userRoutine: AttnRoutineUPP);
  713.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  714.     {To be implemented:  Glue to move parameters into registers.}
  715.     {$ENDC}
  716.  
  717. FUNCTION CallMPPProtocolHandlerProc(SCCAddr1: Ptr; SCCAddr2: Ptr; MPPLocalVars: Ptr; nextFreeByteInRHA: Ptr; ReadPacketAndReadRestPtr: Ptr; numBytesLeftToReadInPacket: INTEGER; userRoutine: MPPProtocolHandlerUPP): BOOLEAN;
  718.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  719.     {To be implemented:  Glue to move parameters into registers.}
  720.     {$ENDC}
  721.  
  722. FUNCTION CallDDPSocketListenerProc(SCCAddr1: Ptr; SCCAddr2: Ptr; MPPLocalVars: Ptr; nextFreeByteInRHA: Ptr; ReadPacketAndReadRestPtr: Ptr; packetDestinationNumber: ByteParameter; numBytesLeftToReadInPacket: INTEGER; userRoutine: DDPSocketListenerUPP): BOOLEAN;
  723.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  724.     {To be implemented:  Glue to move parameters into registers.}
  725.     {$ENDC}
  726. FUNCTION OpenXPP(VAR xppRefnum: INTEGER): OSErr;
  727. FUNCTION ASPOpenSession(thePBptr: XPPParmBlkPtr; async: BOOLEAN): OSErr;
  728. FUNCTION ASPCloseSession(thePBptr: XPPParmBlkPtr; async: BOOLEAN): OSErr;
  729. FUNCTION ASPAbortOS(thePBptr: XPPParmBlkPtr; async: BOOLEAN): OSErr;
  730. FUNCTION ASPGetParms(thePBptr: XPPParmBlkPtr; async: BOOLEAN): OSErr;
  731. FUNCTION ASPCloseAll(thePBptr: XPPParmBlkPtr; async: BOOLEAN): OSErr;
  732. FUNCTION ASPUserWrite(thePBptr: XPPParmBlkPtr; async: BOOLEAN): OSErr;
  733. FUNCTION ASPUserCommand(thePBptr: XPPParmBlkPtr; async: BOOLEAN): OSErr;
  734. FUNCTION ASPGetStatus(thePBptr: XPPParmBlkPtr; async: BOOLEAN): OSErr;
  735. FUNCTION AFPCommand(thePBptr: XPPParmBlkPtr; async: BOOLEAN): OSErr;
  736. FUNCTION GetLocalZones(thePBptr: XPPParmBlkPtr; async: BOOLEAN): OSErr;
  737. FUNCTION GetZoneList(thePBptr: XPPParmBlkPtr; async: BOOLEAN): OSErr;
  738. FUNCTION GetMyZone(thePBptr: XPPParmBlkPtr; async: BOOLEAN): OSErr;
  739. FUNCTION PAttachPH(thePBptr: MPPPBPtr; async: BOOLEAN): OSErr;
  740. FUNCTION PDetachPH(thePBptr: MPPPBPtr; async: BOOLEAN): OSErr;
  741. FUNCTION PWriteLAP(thePBptr: MPPPBPtr; async: BOOLEAN): OSErr;
  742. FUNCTION POpenSkt(thePBptr: MPPPBPtr; async: BOOLEAN): OSErr;
  743. FUNCTION PCloseSkt(thePBptr: MPPPBPtr; async: BOOLEAN): OSErr;
  744. FUNCTION PWriteDDP(thePBptr: MPPPBPtr; async: BOOLEAN): OSErr;
  745. FUNCTION PRegisterName(thePBptr: MPPPBPtr; async: BOOLEAN): OSErr;
  746. FUNCTION PLookupName(thePBptr: MPPPBPtr; async: BOOLEAN): OSErr;
  747. FUNCTION PConfirmName(thePBptr: MPPPBPtr; async: BOOLEAN): OSErr;
  748. FUNCTION PRemoveName(thePBptr: MPPPBPtr; async: BOOLEAN): OSErr;
  749. FUNCTION PSetSelfSend(thePBptr: MPPPBPtr; async: BOOLEAN): OSErr;
  750. FUNCTION PKillNBP(thePBptr: MPPPBPtr; async: BOOLEAN): OSErr;
  751. FUNCTION PGetAppleTalkInfo(thePBptr: MPPPBPtr; async: BOOLEAN): OSErr;
  752. FUNCTION PATalkClosePrep(thePBptr: MPPPBPtr; async: BOOLEAN): OSErr;
  753. FUNCTION POpenATPSkt(thePBptr: ATPPBPtr; async: BOOLEAN): OSErr;
  754. FUNCTION PCloseATPSkt(thePBPtr: ATPPBPtr; async: BOOLEAN): OSErr;
  755. FUNCTION PSendRequest(thePBPtr: ATPPBPtr; async: BOOLEAN): OSErr;
  756. FUNCTION PGetRequest(thePBPtr: ATPPBPtr; async: BOOLEAN): OSErr;
  757. FUNCTION PSendResponse(thePBPtr: ATPPBPtr; async: BOOLEAN): OSErr;
  758. FUNCTION PAddResponse(thePBPtr: ATPPBPtr; async: BOOLEAN): OSErr;
  759. FUNCTION PRelTCB(thePBPtr: ATPPBPtr; async: BOOLEAN): OSErr;
  760. FUNCTION PRelRspCB(thePBPtr: ATPPBPtr; async: BOOLEAN): OSErr;
  761. FUNCTION PNSendRequest(thePBPtr: ATPPBPtr; async: BOOLEAN): OSErr;
  762. FUNCTION PKillSendReq(thePBPtr: ATPPBPtr; async: BOOLEAN): OSErr;
  763. FUNCTION PKillGetReq(thePBPtr: ATPPBPtr; async: BOOLEAN): OSErr;
  764. FUNCTION ATPKillAllGetReq(thePBPtr: ATPPBPtr; async: BOOLEAN): OSErr;
  765. PROCEDURE BuildLAPwds(wdsPtr: Ptr; dataPtr: Ptr; destHost: INTEGER; prototype: INTEGER; frameLen: INTEGER);
  766. PROCEDURE BuildDDPwds(wdsPtr: Ptr; headerPtr: Ptr; dataPtr: Ptr; netAddr: AddrBlock; ddpType: INTEGER; dataLen: INTEGER);
  767. PROCEDURE NBPSetEntity(buffer: Ptr; nbpObject: Str32; nbpType: Str32; nbpZone: Str32);
  768. PROCEDURE NBPSetNTE(ntePtr: Ptr; nbpObject: Str32; nbpType: Str32; nbpZone: Str32; socket: INTEGER);
  769. FUNCTION GetBridgeAddress: INTEGER;
  770. FUNCTION BuildBDS(buffPtr: Ptr; bdsPtr: Ptr; buffSize: INTEGER): INTEGER;
  771. FUNCTION MPPOpen: OSErr;
  772. FUNCTION LAPAddATQ(theATQEntry: ATQEntryPtr): OSErr;
  773. FUNCTION LAPRmvATQ(theATQEntry: ATQEntryPtr): OSErr;
  774. FUNCTION ATPLoad: OSErr;
  775. FUNCTION ATPUnload: OSErr;
  776. FUNCTION NBPExtract(theBuffer: Ptr; numInBuf: INTEGER; whichOne: INTEGER; VAR abEntity: EntityName; VAR address: AddrBlock): OSErr;
  777. FUNCTION GetNodeAddress(VAR myNode: INTEGER; VAR myNet: INTEGER): OSErr;
  778. FUNCTION IsMPPOpen: BOOLEAN;
  779. FUNCTION IsATPOpen: BOOLEAN;
  780. PROCEDURE ATEvent(event: LONGINT; infoPtr: Ptr);
  781. FUNCTION ATPreFlightEvent(event: LONGINT; cancel: LONGINT; infoPtr: Ptr): OSErr;
  782. {
  783.     The following routines are obsolete and will not be supported on
  784.     PowerPC. Equivalent functionality is provided by the routines
  785.     above.
  786. }
  787. {$IFC TARGET_CPU_68K }
  788. FUNCTION MPPClose: OSErr;
  789. FUNCTION LAPOpenProtocol(theLAPType: ByteParameter; protoPtr: Ptr): OSErr;
  790. FUNCTION LAPCloseProtocol(theLAPType: ByteParameter): OSErr;
  791. FUNCTION LAPWrite(abRecord: ATLAPRecHandle; async: BOOLEAN): OSErr;
  792. FUNCTION LAPRead(abRecord: ATLAPRecHandle; async: BOOLEAN): OSErr;
  793. FUNCTION LAPRdCancel(abRecord: ATLAPRecHandle): OSErr;
  794. FUNCTION DDPOpenSocket(VAR theSocket: INTEGER; sktListener: Ptr): OSErr;
  795. FUNCTION DDPCloseSocket(theSocket: INTEGER): OSErr;
  796. FUNCTION DDPRead(abRecord: ATDDPRecHandle; retCksumErrs: BOOLEAN; async: BOOLEAN): OSErr;
  797. FUNCTION DDPWrite(abRecord: ATDDPRecHandle; doChecksum: BOOLEAN; async: BOOLEAN): OSErr;
  798. FUNCTION DDPRdCancel(abRecord: ATDDPRecHandle): OSErr;
  799. FUNCTION ATPOpenSocket(addrRcvd: AddrBlock; VAR atpSocket: INTEGER): OSErr;
  800. FUNCTION ATPCloseSocket(atpSocket: INTEGER): OSErr;
  801. FUNCTION ATPSndRequest(abRecord: ATATPRecHandle; async: BOOLEAN): OSErr;
  802. FUNCTION ATPRequest(abRecord: ATATPRecHandle; async: BOOLEAN): OSErr;
  803. FUNCTION ATPReqCancel(abRecord: ATATPRecHandle; async: BOOLEAN): OSErr;
  804. FUNCTION ATPGetRequest(abRecord: ATATPRecHandle; async: BOOLEAN): OSErr;
  805. FUNCTION ATPSndRsp(abRecord: ATATPRecHandle; async: BOOLEAN): OSErr;
  806. FUNCTION ATPAddRsp(abRecord: ATATPRecHandle): OSErr;
  807. FUNCTION ATPResponse(abRecord: ATATPRecHandle; async: BOOLEAN): OSErr;
  808. FUNCTION ATPRspCancel(abRecord: ATATPRecHandle; async: BOOLEAN): OSErr;
  809. FUNCTION NBPRegister(abRecord: ATNBPRecHandle; async: BOOLEAN): OSErr;
  810. FUNCTION NBPLookup(abRecord: ATNBPRecHandle; async: BOOLEAN): OSErr;
  811. FUNCTION NBPConfirm(abRecord: ATNBPRecHandle; async: BOOLEAN): OSErr;
  812. FUNCTION NBPRemove(abEntity: EntityPtr): OSErr;
  813. FUNCTION NBPLoad: OSErr;
  814. FUNCTION NBPUnload: OSErr;
  815. {$ENDC}  {TARGET_CPU_68K}
  816.  
  817. {$ALIGN RESET}
  818. {$POP}
  819.  
  820. {$SETC UsingIncludes := AppleTalkIncludes}
  821.  
  822. {$ENDC} {__APPLETALK__}
  823.  
  824. {$IFC NOT UsingIncludes}
  825.  END.
  826. {$ENDC}
  827.